In [26]:
import pandas as pd
import datetime
import glob
import json
import matplotlib.pyplot as plt
import numpy as np
import bokeh
import seaborn as sns
import pandas_profiling
import plotly
import plotly.graph_objects as go # Notwendig für Sankey Diagramm
import chart_studio.plotly as py
import pytz
In [27]:
#df= pd.read_csv("data/data1/tirol_sys_21.csv", error_bad_lines=False, sep=";", decimal=",")
#df= pd.read_csv("data/data3/synt_ohne_bat.csv", error_bad_lines=False, sep=";", parse_dates=['DateTime'])
#df= pd.read_csv("data/data1/tirol_sys_21.csv", error_bad_lines=False, sep=";", decimal=",")
#df= pd.read_csv("data/data3/synt_ohne_bat.csv", error_bad_lines=False, sep=";", parse_dates=['DateTime'])
In [28]:
##zum Einlesen der synthetischen Profile
#DF MIT MEDIAN:
#df= pd.read_csv("../data/data3/synt_mit_bat_median.csv", error_bad_lines=False, sep=",")
#Test mit Mittelwert:
df= pd.read_csv("data/data3/tirol_sys_bat_vergleich.csv", error_bad_lines=False, sep=";")
#Test mit Mean und 25% Trim oben und unten:
#df= pd.read_csv("../data/data3/synt_mit_bat_mittelwert_trimmed.csv", error_bad_lines=False, sep=",")
In [29]:
##Zum Einlesen von einzelnen Anlagen:
#df= pd.read_csv("../data/data2/tirol_sys_bat_2.csv", error_bad_lines=False, sep=";", decimal=",")
In [30]:
df.head()
Out[30]:
In [31]:
df.dtypes
Out[31]:
In [32]:
df['DateTime'] = pd.to_datetime(df['DateTime'], format="%Y-%m-%d", utc=True)
df['DateTime'] = df['DateTime'].dt.tz_convert('Europe/Berlin')
In [33]:
#RENAME COLUMNS:
df.columns = ['DateTime', 'DevWork', 'FromBatToCons', 'FromGenToBat','FromGenToCons', 'FromGenToGrid','FromGridToCons','FromGrid', 'StateOfCharge', 'ToCons']
'''
DF shape original:
DateTime datetime64[ns, Europe/Berlin]grou
DevWork_97 [Energy_Ws] float64
FromBattToConsumer_0 [Energy_Wh] int64
FromGenToBatt_0 [Energy_Wh] int64
FromGenToConsumer_0 [Energy_Wh] float64
FromGenToGrid_0 [Energy_Wh] float64
FromGridToConsumer_0 [Energy_Wh] float64
FromGrid_0 [Energy_Wh] float64
ToConsumer_0 [Energy_Wh] float64
dtype: object
'''
Out[33]:
In [34]:
df['FromGen'] = df['FromGenToBat'] + df['FromGenToCons'] + df['FromGenToGrid']
In [35]:
#Pandas Profiling
In [36]:
df.head()
Out[36]:
In [37]:
df.dtypes
Out[37]:
In [38]:
#df['FromBatToCons'] = df['FromBatToCons'].astype(float)
In [39]:
from pandas_profiling import ProfileReport
profile = ProfileReport(df, title="Pandas Profiling Report Synthetisches LP ohne Batterie")
In [40]:
#profile
Überschussmenge Monat/Tag visualisieren:¶
Es wird ein Subset aus der Überschussmenge gebildet (jeweils aggregiert nach Monat und Tag) Außerdem erfolgt noch eine Umrechnung auf kWh um eine bessere Vergleichbarkeit zu ermöglichen.
In [41]:
#hier werden die Daten nach Montaen und Tagen
überschuss_month = df.groupby(pd.Grouper(key='DateTime',freq='M')).agg({'FromGenToGrid':'sum', 'FromGen':'sum'}).reset_index()
überschuss_day = df.groupby(pd.Grouper(key='DateTime',freq='d')).agg({'FromGenToGrid':'sum'}).reset_index()
In [42]:
#Damit alle Werte nach Monaten ausgewertet werden können + Umwandlung in kWh
df_aggr=df.groupby(pd.Grouper(key='DateTime',freq='M')).sum().reset_index()
df_aggr['Datum'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%Y-%m')
df_aggr['Jahr'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%Y')
df_aggr['Monat'] = pd.to_datetime(df_aggr['DateTime']).dt.strftime('%m')
#da die Features FromGenToBat und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
df_aggr["FromBatToCons"] = df_aggr["FromBatToCons"]/1000
except:
pass
try:
df_aggr["FromGenToBat"] = df_aggr["FromGenToBat"]/1000
except:
pass
df_aggr["FromGenToCons"] = df_aggr["FromGenToCons"]/1000
df_aggr["FromGenToGrid"] = df_aggr["FromGenToGrid"]/1000
df_aggr["FromGridToCons"] = df_aggr["FromGridToCons"]/1000
df_aggr["FromGrid"] = df_aggr["FromGrid"]/1000
df_aggr["ToCons"] = df_aggr["ToCons"]/1000
df_aggr["FromGen"] = df_aggr["FromGen"]/1000
del df_aggr['DateTime']
del df_aggr['DevWork']
In [43]:
df_aggr.head()
Out[43]:
In [44]:
#Jahresverbrauch an Strom:
verbr_monat = df_aggr.groupby(df_aggr.Datum ,as_index=True).sum().reset_index()
verbr_jahr = df_aggr.groupby(df_aggr.Jahr ,as_index=True).sum().reset_index()
In [45]:
verbr_jahr
#verbr_jahr.to_csv('Energiemenge_gesamt_Jahr_snyt_mittelwert.csv')
Out[45]:
In [46]:
verbr_jahr_round=verbr_jahr.round(2)
In [47]:
#verbr_jahr_round.to_csv('Energiemenge_gesamt_Jahr_snyt_round_median.csv')
verbr_jahr_round
Out[47]:
In [48]:
#Kontrolle
#verbr_monat.head()
In [49]:
#verbr_monat.distplot('FromGen','ToCons')
In [50]:
#überschuss_month['DateTime'] = pd.to_datetime(überschuss_month['DateTime'], format="%Y-%m")
überschuss_month['Datum'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%Y-%m')
überschuss_month['Jahr'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%Y')
überschuss_month['Monat'] = pd.to_datetime(überschuss_month['DateTime']).dt.strftime('%m')
In [51]:
#überschuss_month['FromGenToGrid'] = (überschuss_month['FromGenToGrid']/1000)
del überschuss_month['DateTime']
In [52]:
überschuss_month["FromGenToGrid"] = (überschuss_month["FromGenToGrid"]/1000)
überschuss_month["FromGen"] = (überschuss_month["FromGen"]/1000)
In [53]:
indexNames = überschuss_month[überschuss_month['Jahr'] == '2021'].index
überschuss_month.drop(indexNames , inplace=True)
#kontrolle:
überschuss_month.head()
Out[53]:
In [54]:
#nun werden die Daten pivotiert, damit später die Jahre untereinander verglichen werden können
piv = pd.pivot_table(überschuss_month, index=['Monat'], columns=['Jahr'], values=['FromGenToGrid', 'FromGen'])
piv.dtypes
Out[54]:
In [55]:
#piv.reset_index()
#Kontrolle:
#piv.head()
In [56]:
piv.plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("Ãœberschusseinspeisung in kWh")
legend = plt.legend(title="Ãœberschusseinspeisung, Jahr",
loc=1, fontsize='large', fancybox=True)
In [57]:
piv['FromGen','2017'].plot(figsize=(15,10))
piv['FromGen','2018'].plot(figsize=(15,10))
piv['FromGen','2019'].plot(figsize=(15,10))
piv['FromGen','2020'].plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("Ãœberschusseinspeisung in kWh")
legend = plt.legend(title="Ãœberschusseinspeisung, Jahr",
loc=1, fontsize='large', fancybox=True)
In [58]:
#Diese Grafik visualisiert, wie viel kWh Pro Jahr von der PV-Anlage ins Netz eingespeist werden (saisonaler Vergleich)
#Diese Menge an Überschuss ist das Potential, das für den Betrieb einen Elektrofahrzeuges genutzt werden könnte.
In [ ]:
In [59]:
#piv.head(200)
#piv.to_csv('pivot_test.csv', index = False)
In [60]:
#Nachfolgend werden die Ãœberschussmengen, welche ins Netz eingespeist werden, anhand der Menge verglichen. Dazu wurden Violin und Boxplots verwendet.
#Speziell der erste Violinplot wäre aus Sicht des Autors optisch interessant gewesen. Da die Eigenschaft des Violinplots allerdings die Aussagekraft verfälscht (der Violinplot läuft im negativen Wertebreeich aus), wurde für die finale Arbeit der Boxpot benutzt.
In [61]:
#Falls nur FromGenToGrid wieder in piv sein soll:
#piv = pd.pivot_table(überschuss_month, index=['Monat'], columns=['Jahr'], values=['FromGenToGrid'])
In [62]:
plt.figure(figsize=(12, 10))
ax = sns.violinplot(#x="Monat", y="FromGenToGrid",
data=piv["FromGenToGrid"], split=True, palette="Set2", title="abc",
scale="count", inner="quartile")
In [63]:
plt.figure(figsize=(12, 10))
ax = sns.violinplot(data=piv, figsize=(200, 100))
In [64]:
plt.figure(figsize=(12, 10))
sns.boxplot(data=piv["FromGenToGrid"])
sns.despine(offset=10, trim=True)
plt.xlabel("Jahr")
plt.ylabel("Ãœberschusseinspeisung in kWh pro Monat")
Out[64]:
In [65]:
plt.figure(figsize=(12, 10))
sns.boxplot(data=piv)
sns.despine(offset=10, trim=True)
plt.xlabel("Jahr")
plt.ylabel("Ãœberschusseinspeisung in kWh pro Monat")
Out[65]:
In [66]:
#Verbrauch und Erzeugung:
In [67]:
df2=verbr_monat
df2['Jahr'] = pd.to_datetime(verbr_monat['Datum']).dt.strftime('%Y')
df2['Monat'] = pd.to_datetime(verbr_monat['Datum']).dt.strftime('%m')
In [68]:
#Kontrolle
#df2.head()
In [69]:
indexNames = df2[df2['Jahr'] == '2021'].index
df2.drop(indexNames , inplace=True)
#kontrolle:
#df2.head()
In [70]:
piv2= pd.pivot_table(df2, index=['Monat'], columns=['Jahr'],
values=['FromBatToCons','FromGenToBat','FromGenToCons','FromGenToGrid','FromGridToCons','FromGrid','ToCons','FromGen'])
In [71]:
#Es wurde ein Durchschnitt aus den 4 Jahren gebildet und diese hier miteinander verglichen.
In [72]:
piv2['FromGen','2018'].plot(figsize=(15,10))
piv2['ToCons','2018'].plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugung und Verbrauch, Jahr",
loc=1, fontsize='large', fancybox=True)
In [73]:
piv2['FromGen'].plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugung, Jahr",
loc=1, fontsize='large', fancybox=True)
In [74]:
piv2['ToCons'].plot(figsize=(15,10))
plt.xlabel("Monat")
plt.ylabel("kWh")
legend = plt.legend(title="Verbrauch, Jahr",
loc=1, fontsize='large', fancybox=True)
In [75]:
#Woche im Sommmer
start_date="2019-09-01"
end_date="2019-09-07"
#start_date="2019-08-18"
#end_date="2019-08-24"
zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]
In [76]:
zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit")
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil im Sommer",
loc=1, fontsize='large', fancybox=True)
In [ ]:
In [77]:
#Woche bei maximaler Tageslänge (Schlechtwetter)
start_date="2019-06-18"
end_date="2019-06-24"
#start_date="2019-08-18"
#end_date="2019-08-24"
zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]
zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit")
plt.ylabel("Wh")
legend = plt.legend(title="Lastprofil bei maximaler Tageslänge",
loc=1, fontsize='large', fancybox=True)
In [78]:
#kürzester Tag
start_date="2019-12-16"
end_date="2019-12-23"
zeit = (df['DateTime'] > start_date) & (df['DateTime'] <= end_date)
zeit = df.loc[zeit]
In [79]:
zeit.plot(figsize=(15,10),x="DateTime", y=["FromGen", "ToCons", 'FromGenToGrid'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit")
plt.ylabel("Wh")
legend = plt.legend(title="Ãœberschusseinspeisung, Jahr",
loc=2, fontsize='large', fancybox=True)
In [80]:
#Hier ist eine übersicht, über die erzeugungssschwächste Zeit im Jahr ersichtlich.
#Anhand der historischen Wetterdaten von timeanddate.de lässt sich erkennen, dass gerade am 21. und 22.12 sehr schlechte Wetterbedingunen herrschten. Außerdem fallen beide Tage auf ein Wochenende, was den Stromverbrauch sichtlich erhöht.
#Diese Kombination aus Wintersonnenwende und schlechtem Wetter zeigt, dass zu dieser Zeit quasi keine Erzeugung stattfindet
#https://www.timeanddate.de/wetter/oesterreich/innsbruck/rueckblick?month=12&year=2019
In [81]:
# Differenz Erzeugung/Bedarf pro Tag:
In [82]:
tageswerte = df.groupby(pd.Grouper(key='DateTime',freq='d')).agg({'FromGen':'sum'},{'FromGen':'sum'}).reset_index()
In [83]:
df_tag=df.groupby(pd.Grouper(key='DateTime',freq='d')).sum().reset_index()
df_tag["Ãœberschuss"] = df_tag["FromGen"]-df_tag["ToCons"]
df_tag['Datum'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%Y-%m-%d')
df_tag['Jahr'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%Y')
df_tag['Monat'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%m')
df_tag['Tag'] = pd.to_datetime(df_tag['DateTime']).dt.strftime('%d')
#da die Features FromGenToBat und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
df_tag["FromBatToCons"] = df_tag["FromBatToCons"]/1000
except:
pass
try:
df_tag["FromGenToBat"] = df_tag["FromGenToBat"]/1000
except:
pass
df_tag["FromGenToCons"] = df_tag["FromGenToCons"]/1000
df_tag["FromGenToGrid"] = df_tag["FromGenToGrid"]/1000
df_tag["FromGridToCons"] = df_tag["FromGridToCons"]/1000
df_tag["FromGrid"] = df_tag["FromGrid"]/1000
df_tag["ToCons"] = df_tag["ToCons"]/1000
df_tag["FromGen"] = df_tag["FromGen"]/1000
df_tag["Ãœberschuss"]= df_tag["Ãœberschuss"]/1000
del df_tag['DateTime']
del df_tag['DevWork']
try:
del df_tag['StateOfCharge']
except:
pass
In [84]:
#Kontrolle
#df_tag.head()
In [85]:
#Der Tag, an dem der größte Erzeugungsüberschuss stattfand:
In [86]:
df_tag.loc[df_tag['Ãœberschuss'].idxmax()]
Out[86]:
In [87]:
#Der Tag, an dem die größte Diskrepanz zwischen Verbrauch und Erzeugung lag:
In [88]:
df_tag.loc[df_tag['Ãœberschuss'].idxmin()]
Out[88]:
In [89]:
'''
#GO SIND AUSKOMMENTIERT, weil sie sehr rechensintensiv bei der Anzeige sind in großen Mengen und die Performance stören
import plotly.graph_objects as go
import numpy as np
x = df_tag["Datum"]
y = df_tag["Ãœberschuss"]
fig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2017-01-01", "2020-12-31"])
fig.add_shape(type='line',
x0=min(x),
y0=0,
x1=max(x),
y1=0,
line=dict(color='Red',),
xref='x',
#yref='y'
)
fig.show()
'''
Out[89]:
In [90]:
''' ähnliches Diagamm wie oben, jedoch grafisch weniger ausgearbeitet, deshalb nicht notwendig
df_tag.plot(figsize=(15,10),x="Datum", y=["Ãœberschuss"])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
plt.xlabel("Zeit")
plt.ylabel("kWh")
legend = plt.legend(title="Erzeugungsüberschuss pro Tag:",
loc=2, fontsize='large', fancybox=True)
'''
Out[90]:
In [91]:
# Barplot der monatlichen Überschüsse bzw. Mindermengen:
In [92]:
df_tag2=df_tag.groupby(pd.Grouper(key='Datum')).sum().reset_index()
In [93]:
#df_tag2=df_mon
df_tag2['Datum'] = pd.to_datetime(df_tag2['Datum']).dt.strftime('%Y-%m')
In [ ]:
In [94]:
#Kontrolle
#df_mon.dtypes
#df_tag2.head()
In [95]:
dfx = df_tag2.groupby(df_tag2.Datum, as_index=True).sum().reset_index()
In [96]:
#dfx["Datum"]=dfx[""]"-"dfx[""]
#dfx.head()
In [ ]:
In [97]:
#sns.set_theme(style="whitegrid")
colors = [1 if c < 0 else 0 for c in dfx["Ãœberschuss"]]
color = ["#63F502", "#EF3C2B", "#4374B3"]
#cmap = sns.diverging_palette(220, 20, as_cmap=True)
# Draw a nested barplot by species and sex
g = sns.catplot(
data=dfx, kind="bar",
x="Datum", y="Ãœberschuss",
hue=colors,
ci="sd", palette=color, alpha=1, height=12,
)
[plt.setp(ax.get_xticklabels(), rotation=45) for ax in g.axes.flat]
#g.ax.axhline(225),
g.despine(left=True)
g.set_axis_labels("Zeitraum in Monaten", "Differenz zwischen Gesamterzeugung und -verbrauch (kWh)")
#g.legend.set_title("Ãœberschussmengen")
g._legend.remove()
In [ ]:
In [99]:
colors = ['' if c < 0 else 0 for c in dfx["Ãœberschuss"]]
#data=df_mon
#x = df_mon["Datum"]
#y = df_mon["Ãœberschuss"]
x = dfx["Datum"]
y = dfx["Ãœberschuss"]
# setting the dimensions of the plot
fig, ax = plt.subplots(figsize=(20, 12))
# drawing the plot
sns.barplot(x, y, ax=ax, hue=colors)
plt.xticks(rotation=45)
plt.show()
In [100]:
#die obige Grafik stellt dar, stellt die Differenz zwischen Gesamterzeugung und -Verbrauch dar. Ist der Wert positiv dargestellt (blau), wurde mehr erzeugt als verbraucht - negative Werte sind rot dargestellt und zeigen an, wie viel kWh in dem Monat merh verbraucht als erzeugt wurden.
In [101]:
dfx= df_tag[['Jahr', 'Monat', 'Tag', 'FromGen', 'Ãœberschuss']].copy()
In [102]:
#Kontrolle
#dfx.head()
Nun soll das Potential der Überschussmengen erneut beleuchtet werden.¶
In [103]:
'''
Während eingangs immer die Differenz zwischen Erzeugung und Verbrauch über einen definierten Zeitraum untersucht wurde, sollen nun
nur die Messungen, in denen mehr erzeugt als verbraucht wurde, untersucht werden.
Hintergrund:
Diese Auswertung soll visualisieren, wie viel Überschuss für ein Ladesystem anfällt, wenn dieser eben nicht in einem Speicher gesammelt wird,
um später wieder dem Haushaltsverbrauch zugeführt wird.
Notwendige Energie wird also vom Netz bezogen und nicht durch frühere Überschüsse kompensiert, da diese dem Elektrofahrzeug zugeführt wird
Dazu wird das Feature "Mehrmenge" erzeugt, welches die Differenz zwischen der gesamten Erzeugungsmenge und dem Eigenverbrauch der Kunden darstellt
'''
Out[103]:
In [104]:
#df6 gibt alle Werte in Wh an, df7 in kWh (da gruppiert)
df6= df
#df.head()
In [105]:
df6['Mehrmenge']=df6['FromGen']-df6['FromGenToCons']
In [106]:
df6
Out[106]:
In [107]:
#df7=df6
df7=df6.groupby(pd.Grouper(key='DateTime',freq='d')).sum().reset_index()
df7['Datum'] = pd.to_datetime(df7['DateTime']).dt.strftime('%Y-%m-%d')
df7['Jahr'] = pd.to_datetime(df7['DateTime']).dt.strftime('%Y')
df7['Monat'] = pd.to_datetime(df7['DateTime']).dt.strftime('%m')
df7['Tag'] = pd.to_datetime(df7['DateTime']).dt.strftime('%d')
#da die Features FromGenToBat und FromBatToCons nicht in allen Anlagen vorhanden ist:
try:
df7["FromBatToCons"] = df7["FromBatToCons"]/1000
except:
pass
try:
df7["FromGenToBat"] = df7["FromGenToBat"]/1000
except:
pass
df7["FromGenToCons"] = df7["FromGenToCons"]/1000
df7["FromGenToGrid"] = df7["FromGenToGrid"]/1000
df7["FromGridToCons"] = df7["FromGridToCons"]/1000
df7["FromGrid"] = df7["FromGrid"]/1000
df7["ToCons"] = df7["ToCons"]/1000
df7["FromGen"] = df7["FromGen"]/1000
df7["Mehrmenge"]= df7["Mehrmenge"]/1000
del df7['DateTime']
try:
del df7['DevWork']
except:
pass
try:
del df7['StateOfCharge']
except:
pass
In [108]:
#del df7["mehrmenge"]
#df7 Mengen in kWh und nach Tag gruppiert
#Kontrolle
df7.head(500)
Out[108]:
In [109]:
jahr_mehr=df7['Mehrmenge'].sum()
jahr_mehr
Out[109]:
In [110]:
jahr_erz=df7['FromGen'].sum()
jahr_erz
Out[110]:
In [111]:
#Da jetzt beide Dataframes vorbereitet sind, erfolgt nun die geplante Visualisierung der Daten:
In [112]:
#x=["2020-01-01","2017-05-22"]
def mymehrmenge():
zeit = (df7['Datum'] > start_date) & (df7['Datum'] <= end_date)
zeit = df7.loc[zeit]
zeit.plot(figsize=(15,10),x="Datum", y=['Mehrmenge'])
#df.plot(x="DateTime", y=["FromGen", "ToCons"])
#plt.xticks(x)
plt.xlabel("Zeit")
plt.ylabel("kWh")
legend = plt.legend(title="Lastprofil", loc=1, fontsize='large', fancybox=True)
In [113]:
start_date="2020-01-01"
end_date="2020-12-31"
mymehrmenge()
In [ ]:
In [114]:
# Gesamtübersicht Stromfluss pro Jahr:
#Dazu werden die gesamten Werte der Jahre 2017-2020 zusammengeführt und daraus der Durchschnitt gebildet:
In [115]:
df3=verbr_jahr_round
In [116]:
df3=df3.drop([4]) #2021 wieder entfernen, damit vier volle Jahre da sind
del df3["StateOfCharge"] #Dieses Feature kann man nicht als Summe übers Jahr nutzen
df3["Jahr"].to_string()
df4=df3.append(df3.mean(numeric_only=True), ignore_index=True)
df4.at[4,'Jahr'] = "Mittel"
In [117]:
df4
Out[117]:
In [118]:
#df5 ist nun ein Gesamtwert über alle Mengen in einem durchschnittlichen Jahr:
df5=df4.loc[[4]]
df5
Out[118]:
In [119]:
# SANKEY:
In [120]:
color_link=[
'#EBBAB5',
'#90EE90',
'#FEF3C7',
'#CBB4D5',
'#CBB4D5',
'#A6E3D7',
]
color_node=[
'#d90d39',
'#A4C964',
'#FEF3C7',
#'#CBB4D5',
'#d90d39',
'#CBB4D5',
'#A6E3D7',
]
# 0 1 2 3 4
label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
source = [0, 1, 1, 1, 4]
target = [2, 2, 3, 4, 2]
value = [df5["FromGridToCons"], df5["FromGenToCons"], df5["FromGenToGrid"], df5["FromGenToBat"], df5["FromBatToCons"]]
# data to dict, dict to sankey
link = dict(source = source, target = target, value = value, color=color_link)
node = dict(label = label, pad=50, thickness=5, color=color_node)
data = go.Sankey(link = link, node=node)
# plot
fig = go.Figure(data)
fig.show()
In [121]:
#Dieses SANKEY-Diagramm visualisiert den Fluss an kWh in einem durchschnittlichem Jahr.
In [ ]:
Stromfluss mittels SANKEY-Diagramme für einzelne Tage/Monate:¶
In [122]:
#da wir das Sankey-Diagramm nun zu verschiedensten Zeiten vergleichen möchten, wird es in eine Funktion verpackt:
def mysankey():
label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
source = [0, 1, 1, 1, 4]
target = [2, 2, 3, 4, 2]
value = [dft["FromGridToCons"], dft["FromGenToCons"], dft["FromGenToGrid"], dft["FromGenToBat"], dft["FromBatToCons"]]
# data to dict, dict to sankey
link = dict(source = source, target = target, value = value, color=color_link)
node = dict(label = label, pad=50, thickness=5, color=color_node)
data = go.Sankey(link = link, node=node)
# plot
fig = go.Figure(data)
fig.show()
In [123]:
# sankey für: 21.6.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-06-21']
mysankey()
In [124]:
# sankey für Winter: 21.12.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-12-21']
mysankey()
In [125]:
# sankey für Sommer: 21.6.2020
dft=df_tag.loc[df_tag['Datum'] == '2020-06-21']
mysankey()
In [126]:
# sankey für Jahr
dft=df4.loc[df4['Jahr'] == '2020']
mysankey()
Sankey für Monate:¶
In [127]:
#df7.dtypes
In [128]:
#Kontrolle
#df7.head()
In [129]:
df8=df7.groupby(["Jahr", "Monat"]).sum().reset_index()
df8['Datum']=df8["Jahr"]+"-"+df8["Monat"]
In [130]:
df8.dtypes
Out[130]:
In [131]:
df8.head()
Out[131]:
In [132]:
def mysankey_monat():
label = ["FromGrid", "FromGen", "ToCons", "Grid", "Battery"]
source = [0, 1, 1, 1, 4]
target = [2, 2, 3, 4, 2]
value = [dfm["FromGridToCons"], dfm["FromGenToCons"], dfm["FromGenToGrid"], dfm["FromGenToBat"], dfm["FromBatToCons"]]
# data to dict, dict to sankey
link = dict(source = source, target = target, value = value, color=color_link)
node = dict(label = label, pad=50, thickness=5, color=color_node)
data = go.Sankey(link = link, node=node)
# plot
fig = go.Figure(data)
fig.show()
In [133]:
# sankey für Juni 2020
dfm=df8.loc[df8['Datum'] == '2017-05']
#mysankey_monat()
In [134]:
# SANKEY FÃœR BELIEBIGES MONAT HIER EINGEBEN:
dfm=df8.loc[df8['Datum'] == '2020-11']
#mysankey_monat()
In [135]:
#dfx.head()
In [136]:
#Für Jahre:
In [137]:
dfj=df7.groupby(["Jahr"]).sum().reset_index()
dfj
Out[137]:
In [138]:
'JAHR AUSWÄHLEN'
dfm=dfj.loc[dfj['Jahr'] == '2020']
mysankey_monat()
In [139]:
##Einzelne zufällige Tage:
In [140]:
#'''
#GO IST WIEDER AUSKOMMENTIERT!
x = df["DateTime"]
y = df["FromGen"]
y = df["ToCons"]
fig = go.Figure(data=go.Scatter(x=x, y=y), layout_xaxis_range=["2017-06-25", "2017-06-30"])
'''fig.add_shape(type='line',
x0=min(x),
y0=0,
x1=max(x),
y1=0,
line=dict(color='Red',),
xref='x',
#yref='y'
)'''
fig.show()
#'''